package com.cictec.middleware.core.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;

import com.cictec.middleware.commons.utils.gps.CoordinateConversion.UTMPoint;

/**
 * 线路地图坐标
 * @author Administrator
 *
 */
@Table(name = "t_map_line")
public class BusLineMapPoint implements Serializable {
	
	/** 线路点地图 UTM坐标 */
	@Transient
	private UTMPoint utmPoint;
	/** 线路点地图 UTM坐标 */
	public UTMPoint getUtmPoint() {
		return utmPoint;
	}
	/** 线路点地图 UTM坐标 */
	public void setUtmPoint(UTMPoint utmPoint) {
		this.utmPoint = utmPoint;
	}

	/**
	 * 主键
	 */
	@Id
	@Column(name = "ml_uuid")
	private String mlUuid;

	/**
	 * 线路uuid
	 */
	@Column(name = "ml_line_uuid")
	private String mlLineUuid;

	/**
	 * 站点uuid
	 */
	@Column(name = "ml_sta_uuid")
	private String mlStaUuid;

	/**
	 * 经度
	 */
	@Column(name = "ml_lng")
	private String mlLng;

	/**
	 * 纬度
	 */
	@Column(name = "ml_lat")
	private String mlLat;

	/**
	 * 序号 从1开始
	 */
	@Column(name = "ml_sequence")
	private Integer mlSequence;

	/**
	 * 线路类型 1：上行 2：下行
	 */
	@Column(name = "ml_line_type")
	private String mlLineType;

	/**
	 * 从起点到该点的距离，单位为米。
	 */
	@Column(name = "ml_distance")
	private Double mlDistance;

	/**
	 * 第几站(自然数为已被绘制的站点, 0为两点之间的中间点, -1位未绘制到站点的点)
	 */
	@Column(name = "ml_whichstop")
	private Integer mlWhichstop;

	/**
	 * 来自同步库 1 来自别的库 0 正常录入数据
	 */
	@Column(name = "ml_flag")
	private Short mlFlag;

	private static final long serialVersionUID = 1L;

	/**
	 * 获取主键
	 *
	 * @return ml_uuid - 主键
	 */
	public String getMlUuid() {
		return mlUuid;
	}

	/**
	 * 设置主键
	 *
	 * @param mlUuid
	 *            主键
	 */
	public void setMlUuid(String mlUuid) {
		this.mlUuid = mlUuid == null ? null : mlUuid.trim();
	}

	/**
	 * 获取线路uuid
	 *
	 * @return ml_line_uuid - 线路uuid
	 */
	public String getMlLineUuid() {
		return mlLineUuid;
	}

	/**
	 * 设置线路uuid
	 *
	 * @param mlLineUuid
	 *            线路uuid
	 */
	public void setMlLineUuid(String mlLineUuid) {
		this.mlLineUuid = mlLineUuid == null ? null : mlLineUuid.trim();
	}

	/**
	 * 获取站点uuid
	 *
	 * @return ml_sta_uuid - 站点uuid
	 */
	public String getMlStaUuid() {
		return mlStaUuid;
	}

	/**
	 * 设置站点uuid
	 *
	 * @param mlStaUuid
	 *            站点uuid
	 */
	public void setMlStaUuid(String mlStaUuid) {
		this.mlStaUuid = mlStaUuid == null ? null : mlStaUuid.trim();
	}

	/**
	 * 获取经度
	 *
	 * @return ml_lng - 经度
	 */
	public String getMlLng() {
		return mlLng;
	}

	/**
	 * 设置经度
	 *
	 * @param mlLng
	 *            经度
	 */
	public void setMlLng(String mlLng) {
		this.mlLng = mlLng == null ? null : mlLng.trim();
	}

	/**
	 * 获取纬度
	 *
	 * @return ml_lat - 纬度
	 */
	public String getMlLat() {
		return mlLat;
	}

	/**
	 * 设置纬度
	 *
	 * @param mlLat
	 *            纬度
	 */
	public void setMlLat(String mlLat) {
		this.mlLat = mlLat == null ? null : mlLat.trim();
	}

	/**
	 * 获取序号
	 *
	 * @return ml_sequence - 序号 从1开始
	 */
	public Integer getMlSequence() {
		return mlSequence;
	}

	/**
	 * 设置序号
	 *
	 * @param mlSequence
	 *            序号  从1开始
	 */
	public void setMlSequence(Integer mlSequence) {
		this.mlSequence = mlSequence;
	}

	/**
	 * 获取线路类型 1：上行 2：下行
	 *
	 * @return ml_line_type - 线路类型 1：上行 2：下行
	 */
	public String getMlLineType() {
		return mlLineType;
	}

	/**
	 * 设置线路类型 1：上行 2：下行
	 *
	 * @param mlLineType
	 *            线路类型 1：上行 2：下行
	 */
	public void setMlLineType(String mlLineType) {
		this.mlLineType = mlLineType == null ? null : mlLineType.trim();
	}

	/**
	 * 获取从起点到该点的距离，单位为米。
	 *
	 * @return ml_distance - 从起点到该点的距离，单位为米。
	 */
	public Double getMlDistance() {
		return mlDistance;
	}

	/**
	 * 设置从起点到该点的距离，单位为米。
	 *
	 * @param mlDistance
	 *            从起点到该点的距离，单位为米。
	 */
	public void setMlDistance(Double mlDistance) {
		this.mlDistance = mlDistance;
	}

	/**
	 * 获取第几站(自然数为已被绘制的站点, 0为两点之间的中间点, -1位未绘制到站点的点)
	 *
	 * @return ml_whichstop - 第几站(自然数为已被绘制的站点, 0为两点之间的中间点, -1位未绘制到站点的点)
	 */
	public Integer getMlWhichstop() {
		return mlWhichstop;
	}

	/**
	 * 设置第几站(自然数为已被绘制的站点, 0为两点之间的中间点, -1位未绘制到站点的点)
	 *
	 * @param mlWhichstop
	 *            第几站(自然数为已被绘制的站点, 0为两点之间的中间点, -1位未绘制到站点的点)
	 */
	public void setMlWhichstop(Integer mlWhichstop) {
		this.mlWhichstop = mlWhichstop;
	}

	/**
	 * 获取来自同步库 1 来自别的库 0 正常录入数据
	 *
	 * @return ml_flag - 来自同步库 1 来自别的库 0 正常录入数据
	 */
	public Short getMlFlag() {
		return mlFlag;
	}

	/**
	 * 设置来自同步库 1 来自别的库 0 正常录入数据
	 *
	 * @param mlFlag
	 *            来自同步库 1 来自别的库 0 正常录入数据
	 */
	public void setMlFlag(Short mlFlag) {
		this.mlFlag = mlFlag;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append(getClass().getSimpleName());
		sb.append(" [");
		sb.append("Hash = ").append(hashCode());
		sb.append(", mlUuid=").append(mlUuid);
		sb.append(", mlLineUuid=").append(mlLineUuid);
		sb.append(", mlStaUuid=").append(mlStaUuid);
		sb.append(", mlLng=").append(mlLng);
		sb.append(", mlLat=").append(mlLat);
		sb.append(", mlSequence=").append(mlSequence);
		sb.append(", mlLineType=").append(mlLineType);
		sb.append(", mlDistance=").append(mlDistance);
		sb.append(", mlWhichstop=").append(mlWhichstop);
		sb.append(", mlFlag=").append(mlFlag);
		sb.append("]");
		return sb.toString();
	}
}